# coding=utf-8
import unittest
import Lab2analyse
import re
import os

# INF 8007 lab 2 - Mikaël Guillemot et Thibaut Stimpfling 
# Ce fichier est la suite de tests de notre lab2. Le serveur n'est pas testé.
#

class Test(unittest.TestCase):


    def setUp(self):
        self.analyser = Lab2analyse.analyse()
        self.analyser.dictionnaire_init()
        file_in =open("./Lexique372.txt")
        file_in = file_in.read().decode('latin1 ').encode ('utf8 ')
        self.bad_word = ['auxx','instaree']
        self.bad_word_2 = ['','instaree']
        self.good_word_3 = ["l'homme"]
        self.bad_word_3 = ["l'ail l'oeilcd"]
        self.good_word = ['a',"l'instar"]
        self.good_word_4 = ['à',"jeun"]
        self.good_word_2 = ['mauvais']
        self.texte = ("un - texte test pour   essayer  ,, " "   , ")
        pass


    def tearDown(self):
        self.analyser = None
        pass
    
    #on test le fonctionnement de recuperation du dico en ligne
    def test_web_dic_init(self):
        # on interdit la recuperation local (ce n'est pas optimal, mais on test
        # bien le code et non uniquement l'existance du dico sur le net.
        # ici le setup est inadapté : on le test.
        self.analyser = None
        self.analyser = Lab2analyse.analyse()
        localdic="./Lexique372.txt"
        tmp = "./Lexique372.old"
        if os.path.isfile(localdic):
            os.rename(localdic, tmp) 
        assert self.analyser.dictionnaire_init()
        if os.path.isfile(tmp):
            os.rename(tmp,localdic) 
        pass
    
        #on test le foctionnement normal
    def test_process(self):
        result = self.analyser.process("Ce texte doit pouvoir être analysé.");
        #on test bien . et non \. (si on utilise une virgule et non un point c'est correct.
        result = re.findall("59.745", result)
        self.assertFalse(result == None,"Process ne fonctionne pas !")
        pass

    # On test que le dictonnaire est correctement crée : 
    # en vérifiant la présence ou l'abscence de certains mots de référence
    def test_dic_creation(self):
        assert "a l'instar" in self.analyser.dico
        assert "marché" in self.analyser.dico
        assert not("courire" in self.analyser.dico)
        
    
        
    # Test des valeurs calculés (nmbre de mots, syllabes, mots ignorés) par la fonction  lookup_list_in_di de lookup dans le dictionnaire : 
    # en injectant une liste de mots valide (avec accent, sans), et deux liste de mots non valides
    # on s'assure que les valeurs retournées sont correctes
        
    def test_lookup_list_in_dic(self):
        self.assertEqual((self.analyser.lookup_list_in_dic((self.good_word))[1][0]),3)
        self.assertEqual((self.analyser.lookup_list_in_dic((self.good_word_2))[1][1]),2)
        self.assertEqual((self.analyser.lookup_list_in_dic((self.bad_word_2),)[1][0]),0)
        self.assertEqual((self.analyser.lookup_list_in_dic((self.bad_word_2))[1][1]),0)
        self.assertEqual((self.analyser.lookup_list_in_dic((self.bad_word))[0]),(self.bad_word))
        self.assertEqual((self.analyser.lookup_list_in_dic((self.bad_word))[1][1]),0)
        
        
    # Test sur le découpage et la mise en forme d'une liste  par la fonction split_list_mots:
    # On s'assure que la liste en sortie ne contient plus de "," , " " et plus de '"'
     
    def test_split_list_mots(self):
        liste = self.analyser.split_list_mots(self.texte)
        for mots in liste:
            self.assertEqual(len(re.findall(" ",mots)),0)
            self.assertEqual(len(re.findall(",",mots)),0)
            self.assertEqual(len(re.findall('"',mots)),0)
    
    
    # Test de recherche dans un dictionnaire :
    # On vérifie que la fonction last_lookup permet de matcher des mots que la fonction lookup_list_in_dic ne match pas
    # On vérfie aussi aussi que les mots non présents dans le dictionnaire ne sont pas matchés
    
    def test_last_lookup(self):
        self.assertEqual(self.analyser.last_lookup(self.good_word_3)[1][0],2)    
        self.assertEqual((self.analyser.last_lookup((self.good_word_3))[0]),[])  
        self.assertEqual((self.analyser.last_lookup((self.bad_word_3))[1][0]),3)  
        self.assertEqual((self.analyser.last_lookup((self.bad_word_3))[0][0]),"oeilcd")   
        
        
    #test réalisé : on teste la fonction en envoyant une liste composé de deux éléments qui forment un mot.
    # On vérifie que des mots qui n'existent pas dans le dictionnaire sont retournés, et pour ceux existant dans le dictionnaire
    # le nombre de syllabes calculé est cohérent   
    
    def test_two_words_in_one_lookup(self):
        self.assertEqual((self.analyser.two_words_in_one_lookup((self.bad_word))[0]),(self.bad_word))
        self.assertEqual((self.analyser.two_words_in_one_lookup((self.good_word))[1][1]),3)
        self.assertEqual((self.analyser.two_words_in_one_lookup((self.good_word_4))[1][1]),2)




if __name__ == "__main__":
    #import sys;sys.argv = ['', 'Test.testName']
    unittest.main()